class MyTools {
    /**
     * 唯一的随机字符串，用来区分每条数据
     * @returns {string}
     */
    getUid(){
        return Number(Math.random().toString().substr(2, 16) + Date.now()).toString(32);
    }

    /**
     * 计算时间差
     * @param beginTime：2022-01-13
     * @param endTime：2022-01-13
     * @returns {{hours: number, seconds: number, minutes: number, day: number}}
     */
    dealTime(beginTime,endTime) {
        var dateBegin = new Date(beginTime);
        var dateEnd = new Date(endTime);
        var dateDiff = dateEnd.getTime() - dateBegin.getTime(); //时间差的毫秒数
        var day = Math.floor(dateDiff / (24 * 3600 * 1000)); //计算出相差天数
        var leave1 = dateDiff % (24 * 3600 * 1000); //计算天数后剩余的毫秒数
        var hours = Math.floor(leave1 / (3600 * 1000)); //计算出小时数
        //计算相差分钟数
        var leave2 = leave1 % (3600 * 1000); //计算小时数后剩余的毫秒数
        var minutes = Math.floor(leave2 / (60 * 1000)); //计算相差分钟数

        //计算相差秒数
        var leave3 = leave2 % (60 * 1000); //计算分钟数后剩余的毫秒数
        var seconds = Math.round(leave3 / 1000);
        return {
            day,
            hours,
            minutes,
            seconds
        }
    }
     /**
     * 获取当天日期
     */
    getCurDay(){
        var datetime = new Date();
        var year = datetime.getFullYear();
        var month = datetime.getMonth() + 1 < 10 ? "0" + (datetime.getMonth() + 1) : datetime.getMonth() + 1;
        var date = datetime.getDate() < 10 ? "0" + datetime.getDate() : datetime.getDate();
        return `${year}-${month}-${date}`
    }
    /**
     * 数组中，某个属性相同的数据放在一块，如把某个日期相同的相连一起
     * @param list 传入的数组
     * @param prop 那个属性相同的数据
     * @returns {*[]}
     */
    margePropData(list = [], prop) {
        let arr = [], tempArr = {};
        list.forEach(item => {
            if (!tempArr[item[prop]]) {
                tempArr[item[prop]] = [item]
            } else {
                tempArr[item[prop]].push(item)
            }
        })
        for (const tempArrKey in tempArr) {
            arr = [...arr, ...tempArr[tempArrKey]]
        }
        return arr
    }
     /**
     * 合并行
     * @param list
     * @param prop
     */
    mergeRows(list = [], prop) {
        list.forEach(ele => {
            ele.rowspan = 1
        })
        const len = list.length
        for (let i = 0; i < len; i++) {
            for (let j = i + 1; j < len; j++) {
                if (list[i][prop] === list[j][prop]) {
                    list[i].rowspan++
                    list[j].rowspan--
                }
            }
            // 这里跳过已经重复的数据
            i = i + list[i].rowspan - 1
        }
        return list
    }

    /**
     * 根据当前数据的位置，在数组中插入数据
     * 如数组【1，2，4，5】想要在2后面插入3，
     *1：首先获取到2的下标，
     *2：然后获取要插入之前的数据，获取要插入之后的数据，中间就是插入的位置
     *3：最后把这三个按顺序合并就得到在想要的位置插入数据
     * @param list 想要插入的数组
     * @param index 插入那个值的后面的下标
     * @param target 插入的目标
     */
    insertArrPositionOfIndex(list = [], index = 0, target = {}) {
        //根据index 找出小于index的数据放在左边
        const leftList = list.filter((t, i) => i <= index);
        //根据index 找出大于index的数据放在右边
        const rightList = list.filter((t, i) => i > index);
        // 最终合并数据
        return [...leftList, target, ...rightList]
    }

    /**
     * 校验规则
     */
    verifyRules(list=[],require=[]){
        let message=null
        for (const key of require) {
            const isEmpty= list.every(it=>!it[key.prop])
            if(isEmpty){
                message=key.message
                break ;
            }
        }
        return message
    }
    /**
     * 获取元素下标
     * @param dir 为 1：得到正序遍历方法；为 -1： 得到逆序遍历方法。
     * @returns {(function(*, *, *=): (number|number|number))|*}
     */
    findArrIndex(dir=1) {
        return function (array, cb, context) {
            let length = array.length;
            // 控制初始 index，0 或者 length-1
            let index = dir >= 0 ? 0 : length - 1;

            // 条件： 在数组范围内；
            // 递增或递减：递加 1 或者 -1； 妙啊~
            for( ; index >= 0 && index <= length - 1; index += dir ) {
                if( cb.call(context, array[index], index) ) return index
            }
            return -1
        }
    }
}

export default new MyTools()